dph-prim-seq-0.4.0: Sequential Primitives for Data-Parallel Haskell.Source codeContentsIndex
Data.Array.Parallel.Unlifted.Sequential
Contents
Array classes
Array types
Basic operations
Subarrays
Permutations
Higher-order operations
Searching
Logical operations
Arithmetic operations
Arrays of pairs
Enumerations
Searching
Conversions to/from lists
Unlifted.Sequential arrays
I/O
Basic operations (segmented)
Higher-order operations (segmented)
Higher-order operations (regular)
Logical operations (segmented)
Arithmetic operations (segmented)
Arithmetic operations (regular segmented)
Segment descriptors
Mutable arrays
Library id
Description

(c) [2006..2007] Manuel M T Chakravarty & Roman Leshchinskiy License : see librariesndpLICENSE

Maintainer : Roman Leshchinskiy rl@cse.unsw.edu.au Stability : experimental Portability : portable

Description ---------------------------------------------------------------

External interface to unlifted arrays.

Todo ----------------------------------------------------------------------

Synopsis
class HS e => UA e where
data UArr e
data MUArr e :: * -> *
lengthU :: UArr e -> Int
sliceU :: UArr e -> Int -> Int -> UArr e
newMU :: Int -> ST s (MUArr e s)
hasAtomicWriteMU :: e -> Bool
copyMU :: MUArr e s -> Int -> UArr e -> ST s ()
data USegd
nullU :: UA e => UArr e -> Bool
emptyU :: UA e => UArr e
singletonU :: UA e => e -> UArr e
consU :: UA e => e -> UArr e -> UArr e
unitsU :: Int -> UArr ()
replicateU :: UA e => Int -> e -> UArr e
(!:) :: UA e => UArr e -> Int -> e
(+:+) :: UA e => UArr e -> UArr e -> UArr e
indexedU :: UA e => UArr e -> UArr (Int :*: e)
repeatU :: UA e => Int -> UArr e -> UArr e
extractU :: UA a => UArr a -> Int -> Int -> UArr a
tailU :: UA e => UArr e -> UArr e
takeU :: UA e => Int -> UArr e -> UArr e
dropU :: UA e => Int -> UArr e -> UArr e
splitAtU :: UA e => Int -> UArr e -> (UArr e, UArr e)
permuteU :: UA e => UArr e -> UArr Int -> UArr e
mbpermuteU :: (UA e, UA d) => (e -> d) -> UArr e -> UArr Int -> UArr d
bpermuteU :: UA e => UArr e -> UArr Int -> UArr e
bpermuteDftU :: UA e => Int -> (Int -> e) -> UArr (Int :*: e) -> UArr e
reverseU :: UA e => UArr e -> UArr e
updateU :: UA e => UArr e -> UArr (Int :*: e) -> UArr e
mapU :: (UA e, UA e') => (e -> e') -> UArr e -> UArr e'
zipWithU :: (UA a, UA b, UA c) => (a -> b -> c) -> UArr a -> UArr b -> UArr c
zipWith3U :: (UA a, UA b, UA c, UA d) => (a -> b -> c -> d) -> UArr a -> UArr b -> UArr c -> UArr d
filterU :: UA e => (e -> Bool) -> UArr e -> UArr e
packU :: UA e => UArr e -> UArr Bool -> UArr e
foldlU :: UA a => (b -> a -> b) -> b -> UArr a -> b
foldl1U :: UA a => (a -> a -> a) -> UArr a -> a
foldl1MaybeU :: UA a => (a -> a -> a) -> UArr a -> MaybeS a
foldU :: UA a => (a -> a -> a) -> a -> UArr a -> a
fold1U :: UA a => (a -> a -> a) -> UArr a -> a
fold1MaybeU :: UA a => (a -> a -> a) -> UArr a -> MaybeS a
scanlU :: (UA a, UA b) => (b -> a -> b) -> b -> UArr a -> UArr b
scanl1U :: UA a => (a -> a -> a) -> UArr a -> UArr a
scanU :: UA a => (a -> a -> a) -> a -> UArr a -> UArr a
scan1U :: UA a => (a -> a -> a) -> UArr a -> UArr a
scanResU :: UA a => (a -> a -> a) -> a -> UArr a -> UArr a :*: a
mapAccumLU :: (UA a, UA b) => (c -> a -> c :*: b) -> c -> UArr a -> UArr b
combineU :: UA a => UArr Bool -> UArr a -> UArr a -> UArr a
combineSU :: UA a => UArr Bool -> USegd -> UArr a -> USegd -> UArr a -> UArr a
elemU :: (Eq e, UA e) => e -> UArr e -> Bool
notElemU :: (Eq e, UA e) => e -> UArr e -> Bool
andU :: UArr Bool -> Bool
orU :: UArr Bool -> Bool
anyU :: UA e => (e -> Bool) -> UArr e -> Bool
allU :: UA e => (e -> Bool) -> UArr e -> Bool
sumU :: (Num e, UA e) => UArr e -> e
productU :: (Num e, UA e) => UArr e -> e
maximumU :: (Ord e, UA e) => UArr e -> e
minimumU :: (Ord e, UA e) => UArr e -> e
maximumByU :: UA e => (e -> e -> Ordering) -> UArr e -> e
minimumByU :: UA e => (e -> e -> Ordering) -> UArr e -> e
maximumIndexU :: (Ord e, UA e) => UArr e -> Int
minimumIndexU :: (Ord e, UA e) => UArr e -> Int
maximumIndexByU :: UA e => (e -> e -> Ordering) -> UArr e -> Int
minimumIndexByU :: UA e => (e -> e -> Ordering) -> UArr e -> Int
zipU :: (UA a, UA b) => UArr a -> UArr b -> UArr (a :*: b)
zip3U :: (UA e1, UA e2, UA e3) => UArr e1 -> UArr e2 -> UArr e3 -> UArr ((e1 :*: e2) :*: e3)
unzipU :: (UA a, UA b) => UArr (a :*: b) -> UArr a :*: UArr b
unzip3U :: (UA e1, UA e2, UA e3) => UArr ((e1 :*: e2) :*: e3) -> (UArr e1 :*: UArr e2) :*: UArr e3
fstU :: (UA a, UA b) => UArr (a :*: b) -> UArr a
sndU :: (UA a, UA b) => UArr (a :*: b) -> UArr b
enumFromToU :: Int -> Int -> UArr Int
enumFromThenToU :: Int -> Int -> Int -> UArr Int
enumFromStepLenU :: Int -> Int -> Int -> UArr Int
enumFromToEachU :: Int -> UArr (Int :*: Int) -> UArr Int
enumFromStepLenEachU :: Int -> UArr ((Int :*: Int) :*: Int) -> UArr Int
findU :: UA a => (a -> Bool) -> UArr a -> Maybe a
findIndexU :: UA a => (a -> Bool) -> UArr a -> Maybe Int
toU :: UA e => [e] -> UArr e
fromU :: UA e => UArr e -> [e]
randomU :: (UA a, Random a, RandomGen g) => Int -> g -> UArr a
randomRU :: (UA a, Random a, RandomGen g) => Int -> (a, a) -> g -> UArr a
class UA a => UIO a where
hPutU :: Handle -> UArr a -> IO ()
hGetU :: Handle -> IO (UArr a)
replicateSU :: UA a => USegd -> UArr a -> UArr a
replicateRSU :: UA a => Int -> UArr a -> UArr a
appendSU :: UA a => USegd -> UArr a -> USegd -> UArr a -> UArr a
foldlSU :: (UA a, UA b) => (b -> a -> b) -> b -> USegd -> UArr a -> UArr b
foldSU :: UA a => (a -> a -> a) -> a -> USegd -> UArr a -> UArr a
fold1SU :: UA a => (a -> a -> a) -> USegd -> UArr a -> UArr a
foldlRU :: (UA a, UA b) => (b -> a -> b) -> b -> Int -> Int -> UArr a -> UArr b
andSU :: USegd -> UArr Bool -> UArr Bool
orSU :: USegd -> UArr Bool -> UArr Bool
sumSU :: (Num e, UA e) => USegd -> UArr e -> UArr e
productSU :: (Num e, UA e) => USegd -> UArr e -> UArr e
maximumSU :: (Ord e, UA e) => USegd -> UArr e -> UArr e
minimumSU :: (Ord e, UA e) => USegd -> UArr e -> UArr e
sumRU :: (Num e, UA e) => Int -> Int -> UArr e -> UArr e
lengthUSegd :: USegd -> Int
lengthsUSegd :: USegd -> UArr Int
indicesUSegd :: USegd -> UArr Int
elementsUSegd :: USegd -> Int
lengthsToUSegd :: UArr Int -> USegd
mkUSegd :: UArr Int -> UArr Int -> Int -> USegd
newU :: UA e => Int -> (forall s. MUArr e s -> ST s ()) -> UArr e
permuteMU :: UA e => MUArr e s -> UArr e -> UArr Int -> ST s ()
atomicUpdateMU :: UA e => MUArr e s -> UArr (Int :*: e) -> ST s ()
unsafeFreezeAllMU :: UA e => MUArr e s -> ST s (UArr e)
idstr :: [Char]
name :: [Char]
versnum :: [Char]
date :: [Char]
version :: [Char]
copyright :: [Char]
disclaimer :: [Char]
lengthU' :: UA e => UArr e -> Int
Array classes
class HS e => UA e whereSource

Basic operations on representation types -----------------------------------------

This type class determines the types that can be elements immutable unboxed arrays. The representation type of these arrays is defined by way of an associated type. All representation-dependent functions are methods of this class.

Associated Types
data UArr e Source
data MUArr e :: * -> *Source
Methods
lengthU :: UArr e -> IntSource
Yield the length of an unboxed array
sliceU :: UArr e -> Int -> Int -> UArr eSource
Restrict access to a subrange of the original array (no copying)
newMU :: Int -> ST s (MUArr e s)Source
Allocate a mutable unboxed array
hasAtomicWriteMU :: e -> BoolSource
Indicate whether the type supports atomic updates
copyMU :: MUArr e s -> Int -> UArr e -> ST s ()Source
Copy the contents of an immutable unboxed array into a mutable one from the specified position on
show/hide Instances
Array types
data USegd Source
Segment descriptors represent the structure of nested arrays. For each segment, it stores the length and the starting index in the flat data array.
show/hide Instances
Basic operations
nullU :: UA e => UArr e -> BoolSource
Test whether the given array is empty
emptyU :: UA e => UArr eSource
Yield an empty array
singletonU :: UA e => e -> UArr eSource
Yield a singleton array
consU :: UA e => e -> UArr e -> UArr eSource
Prepend an element to an array
unitsU :: Int -> UArr ()Source

Basic operations on unboxed arrays -----------------------------------

Yield an array of units

replicateU :: UA e => Int -> e -> UArr eSource
Yield an array where all elements contain the same value
(!:) :: UA e => UArr e -> Int -> eSource
Array indexing
(+:+) :: UA e => UArr e -> UArr e -> UArr eSource
Concatenate two arrays
indexedU :: UA e => UArr e -> UArr (Int :*: e)Source

Indexing ---------

Associate each element of the array with its index

repeatU :: UA e => Int -> UArr e -> UArr eSource
Repeat an array n times
Subarrays
extractU :: UA a => UArr a -> Int -> Int -> UArr aSource
tailU :: UA e => UArr e -> UArr eSource
Yield the tail of an array
takeU :: UA e => Int -> UArr e -> UArr eSource
Extract a prefix of an array
dropU :: UA e => Int -> UArr e -> UArr eSource
Extract a suffix of an array
splitAtU :: UA e => Int -> UArr e -> (UArr e, UArr e)Source
Split an array into two halves at the given index
Permutations
permuteU :: UA e => UArr e -> UArr Int -> UArr eSource
Standard permutation
mbpermuteU :: (UA e, UA d) => (e -> d) -> UArr e -> UArr Int -> UArr dSource
bpermuteU :: UA e => UArr e -> UArr Int -> UArr eSource

Back permutation operation (ie, the permutation vector determines for each position in the result array its origin in the input array)

WARNING: DO NOT rewrite this as unstreamU . bpermuteUS es . streamU because GHC won't be able to figure out its strictness.

bpermuteDftUSource
:: UA e
=> Intlength of result array
-> Int -> einitialiser function
-> UArr (Int :*: e)index-value pairs
-> UArr e

Default back permute

  • The values of the index-value pairs are written into the position in the result array that is indicated by the corresponding index.
  • All positions not covered by the index-value pairs will have the value determined by the initialiser function for that index position.
reverseU :: UA e => UArr e -> UArr eSource
Reverse the order of elements in an array
updateU :: UA e => UArr e -> UArr (Int :*: e) -> UArr eSource
Yield an array constructed by updating the first array by the associations from the second array (which contains index/value pairs).
Higher-order operations
mapU :: (UA e, UA e') => (e -> e') -> UArr e -> UArr e'Source
Map a function over an array
zipWithU :: (UA a, UA b, UA c) => (a -> b -> c) -> UArr a -> UArr b -> UArr cSource
zipWith3U :: (UA a, UA b, UA c, UA d) => (a -> b -> c -> d) -> UArr a -> UArr b -> UArr c -> UArr dSource
filterU :: UA e => (e -> Bool) -> UArr e -> UArr eSource
Extract all elements from an array that meet the given predicate
packU :: UA e => UArr e -> UArr Bool -> UArr eSource
Extract all elements from an array according to a given flag array
foldlU :: UA a => (b -> a -> b) -> b -> UArr a -> bSource
Array reduction proceeding from the left
foldl1U :: UA a => (a -> a -> a) -> UArr a -> aSource

Array reduction proceeding from the left for non-empty arrays

FIXME: Rewrite for Streams.

foldl1MaybeU :: UA a => (a -> a -> a) -> UArr a -> MaybeS aSource
foldU :: UA a => (a -> a -> a) -> a -> UArr a -> aSource
Array reduction that requires an associative combination function with its unit
fold1U :: UA a => (a -> a -> a) -> UArr a -> aSource
Reduction of a non-empty array which requires an associative combination function
fold1MaybeU :: UA a => (a -> a -> a) -> UArr a -> MaybeS aSource
scanlU :: (UA a, UA b) => (b -> a -> b) -> b -> UArr a -> UArr bSource
Prefix scan proceedings from left to right
scanl1U :: UA a => (a -> a -> a) -> UArr a -> UArr aSource
Prefix scan of a non-empty array proceeding from left to right
scanU :: UA a => (a -> a -> a) -> a -> UArr a -> UArr aSource
Prefix scan proceeding from left to right that needs an associative combination function with its unit
scan1U :: UA a => (a -> a -> a) -> UArr a -> UArr aSource
Prefix scan of a non-empty array proceeding from left to right that needs an associative combination function
scanResU :: UA a => (a -> a -> a) -> a -> UArr a -> UArr a :*: aSource
mapAccumLU :: (UA a, UA b) => (c -> a -> c :*: b) -> c -> UArr a -> UArr bSource

Accumulating map from left to right. Does not return the accumulator.

FIXME: Naming inconsistent with lists.

combineU :: UA a => UArr Bool -> UArr a -> UArr a -> UArr aSource
combineSU :: UA a => UArr Bool -> USegd -> UArr a -> USegd -> UArr a -> UArr aSource
Merge two segmented arrays according to flag array
Searching
elemU :: (Eq e, UA e) => e -> UArr e -> BoolSource
Determine whether the given element is in an array
notElemU :: (Eq e, UA e) => e -> UArr e -> BoolSource
Negation of elemU
Logical operations
andU :: UArr Bool -> BoolSource
orU :: UArr Bool -> BoolSource
anyU :: UA e => (e -> Bool) -> UArr e -> BoolSource
allU :: UA e => (e -> Bool) -> UArr e -> BoolSource
Arithmetic operations
sumU :: (Num e, UA e) => UArr e -> eSource
Compute the sum of an array of numerals
productU :: (Num e, UA e) => UArr e -> eSource
Compute the product of an array of numerals
maximumU :: (Ord e, UA e) => UArr e -> eSource
Determine the maximum element in an array
minimumU :: (Ord e, UA e) => UArr e -> eSource
Determine the minimum element in an array
maximumByU :: UA e => (e -> e -> Ordering) -> UArr e -> eSource
Determine the maximum element in an array under the given ordering
minimumByU :: UA e => (e -> e -> Ordering) -> UArr e -> eSource
Determine the minimum element in an array under the given ordering
maximumIndexU :: (Ord e, UA e) => UArr e -> IntSource
Determine the index of the maximum element in an array
minimumIndexU :: (Ord e, UA e) => UArr e -> IntSource
Determine the index of the minimum element in an array
maximumIndexByU :: UA e => (e -> e -> Ordering) -> UArr e -> IntSource
Determine the index of the maximum element in an array under the given ordering
minimumIndexByU :: UA e => (e -> e -> Ordering) -> UArr e -> IntSource
Determine the index of the minimum element in an array under the given ordering
Arrays of pairs
zipU :: (UA a, UA b) => UArr a -> UArr b -> UArr (a :*: b)Source
Elementwise pairing of array elements.
zip3U :: (UA e1, UA e2, UA e3) => UArr e1 -> UArr e2 -> UArr e3 -> UArr ((e1 :*: e2) :*: e3)Source
unzipU :: (UA a, UA b) => UArr (a :*: b) -> UArr a :*: UArr bSource
Elementwise unpairing of array elements.
unzip3U :: (UA e1, UA e2, UA e3) => UArr ((e1 :*: e2) :*: e3) -> (UArr e1 :*: UArr e2) :*: UArr e3Source
fstU :: (UA a, UA b) => UArr (a :*: b) -> UArr aSource
Yield the first components of an array of pairs.
sndU :: (UA a, UA b) => UArr (a :*: b) -> UArr bSource
Yield the second components of an array of pairs.
Enumerations
enumFromToU :: Int -> Int -> UArr IntSource

Yield an enumerated array

FIXME: See comments about enumFromThenToS

enumFromThenToU :: Int -> Int -> Int -> UArr IntSource

Yield an enumerated array using a specific step

FIXME: See comments about enumFromThenToS

enumFromStepLenU :: Int -> Int -> Int -> UArr IntSource
enumFromToEachU :: Int -> UArr (Int :*: Int) -> UArr IntSource
enumFromStepLenEachU :: Int -> UArr ((Int :*: Int) :*: Int) -> UArr IntSource
Searching
findU :: UA a => (a -> Bool) -> UArr a -> Maybe aSource
findIndexU :: UA a => (a -> Bool) -> UArr a -> Maybe IntSource
Conversions to/from lists
toU :: UA e => [e] -> UArr eSource

Conversion -----------

Turn a list into a parallel array

fromU :: UA e => UArr e -> [e]Source
Collect the elements of a parallel array in a list
Unlifted.Sequential arrays
randomU :: (UA a, Random a, RandomGen g) => Int -> g -> UArr aSource
randomRU :: (UA a, Random a, RandomGen g) => Int -> (a, a) -> g -> UArr aSource
I/O
class UA a => UIO a whereSource
Methods
hPutU :: Handle -> UArr a -> IO ()Source
hGetU :: Handle -> IO (UArr a)Source
show/hide Instances
UIO Double
UIO Int
(UIO a, UIO b) => UIO (:*: a b)
Basic operations (segmented)
replicateSU :: UA a => USegd -> UArr a -> UArr aSource
replicateRSU :: UA a => Int -> UArr a -> UArr aSource
appendSU :: UA a => USegd -> UArr a -> USegd -> UArr a -> UArr aSource
Higher-order operations (segmented)
foldlSU :: (UA a, UA b) => (b -> a -> b) -> b -> USegd -> UArr a -> UArr bSource
Segmented array reduction proceeding from the left
foldSU :: UA a => (a -> a -> a) -> a -> USegd -> UArr a -> UArr aSource
Segmented array reduction that requires an associative combination function with its unit
fold1SU :: UA a => (a -> a -> a) -> USegd -> UArr a -> UArr aSource
Segmented array reduction with non-empty subarrays and an associative combination function
Higher-order operations (regular)
foldlRU :: (UA a, UA b) => (b -> a -> b) -> b -> Int -> Int -> UArr a -> UArr bSource
Regular arrar reduction
Logical operations (segmented)
andSU :: USegd -> UArr Bool -> UArr BoolSource
orSU :: USegd -> UArr Bool -> UArr BoolSource
Arithmetic operations (segmented)
sumSU :: (Num e, UA e) => USegd -> UArr e -> UArr eSource
Compute the segmented sum of an array of numerals
productSU :: (Num e, UA e) => USegd -> UArr e -> UArr eSource
Compute the segmented product of an array of numerals
maximumSU :: (Ord e, UA e) => USegd -> UArr e -> UArr eSource
Determine the maximum element in each subarray
minimumSU :: (Ord e, UA e) => USegd -> UArr e -> UArr eSource
Determine the minimum element in each subarray
Arithmetic operations (regular segmented)
sumRU :: (Num e, UA e) => Int -> Int -> UArr e -> UArr eSource
Compute the segmented sum of an array of numerals
Segment descriptors
lengthUSegd :: USegd -> IntSource

Operations on segment descriptors ----------------------------------

Yield the overall number of segments

lengthsUSegd :: USegd -> UArr IntSource
Yield the segment lengths of a segment descriptor
indicesUSegd :: USegd -> UArr IntSource
Yield the segment indices of a segment descriptor
elementsUSegd :: USegd -> IntSource
Yield the number of data elements
lengthsToUSegd :: UArr Int -> USegdSource
Convert a length array into a segment descriptor.
mkUSegd :: UArr Int -> UArr Int -> Int -> USegdSource
Mutable arrays
newU :: UA e => Int -> (forall s. MUArr e s -> ST s ()) -> UArr eSource
Creating unboxed arrays ------------------------
permuteMU :: UA e => MUArr e s -> UArr e -> UArr Int -> ST s ()Source
Permutations -------------
atomicUpdateMU :: UA e => MUArr e s -> UArr (Int :*: e) -> ST s ()Source
unsafeFreezeAllMU :: UA e => MUArr e s -> ST s (UArr e)Source
Library id
idstr :: [Char]Source
name :: [Char]Source
versnum :: [Char]Source
date :: [Char]Source
version :: [Char]Source
copyright :: [Char]Source
disclaimer :: [Char]Source
lengthU' :: UA e => UArr e -> IntSource
FIXME: A fuseable version of lengthU, should go away
Produced by Haddock version 2.6.1